package com.xiaowu.xblog.web;// ==================== 通用Controller ====================
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.xiaowu.xblog.model.PageQuery;
import com.xiaowu.xblog.service.BaseService;
import com.xiaowu.xblog.utils.Result;
import org.springframework.web.bind.annotation.*;
import java.io.Serializable;
import java.util.List;

/**
 * 通用基础 Controller，提供常用的 CRUD 接口
 * @param <S> Service 类型，继承 BaseService<T>
 * @param <T> 实体类型
 */
public abstract class BaseController<S extends BaseService<T>, T> {

    protected S service;

    protected BaseController(S service) {
        this.service = service;
    }

    /**
     * 新增一条记录
     * @param entity 实体对象
     * @return 操作结果
     */
    @PostMapping
    public Result<String> create(@RequestBody T entity) {
        boolean result = service.create(entity);
        return Result.success("success");
    }

    /**
     * 批量新增记录
     * @param entityList 实体对象列表
     * @return 是否成功
     */
    @PostMapping("/batch")
    public Result<Boolean> createBatch(@RequestBody List<T> entityList) {
        boolean result = service.createBatch(entityList);
        if(result){
            return Result.success("success", true);
        }
        return Result.error("error");
    }

    /**
     * 根据主键 ID 删除单条记录
     * @param id 主键 ID
     * @return 是否删除成功
     */
    @DeleteMapping("/{id}")
    public Result<Boolean> deleteById(@PathVariable Serializable id) {
        boolean result = service.deleteById(id);
        return Result.success("success", result);
    }

    /**
     * 根据 ID 列表批量删除记录
     * @param idList 主键 ID 列表
     * @return 是否删除成功
     */
    @DeleteMapping("/batch")
    public Result<Boolean> deleteByIds(@RequestBody List<? extends Serializable> idList) {
        boolean result = service.deleteByIds(idList);
        return Result.success("success", result);
    }

    /**
     * 根据 ID 更新单条记录
     * @param entity 实体对象（必须包含 ID）
     * @return 是否更新成功
     */
    @PutMapping
    public Result<Boolean> updateById(@RequestBody T entity) {
        boolean result = service.updateById(entity);
        return Result.success("success", result);
    }

    /**
     * 批量根据 ID 更新记录
     * @param entityList 实体对象列表（每个对象必须包含 ID）
     * @return 是否更新成功
     */
    @PutMapping("/batch")
    public Result<Boolean> updateBatchById(@RequestBody List<T> entityList) {
        boolean result = service.updateBatchById(entityList);
        return Result.success("success", result);
    }

    /**
     * 根据 ID 查询单条记录
     * @param id 主键 ID
     * @return 查询结果
     */
    @GetMapping("/{id}")
    public Result<T> findById(@PathVariable Serializable id) {
        T result = service.findById(id);
        return Result.success("success", result);
    }

    /**
     * 根据 ID 列表查询多条记录
     * @param idList 主键 ID 列表
     * @return 查询结果列表
     */
    @PostMapping("/ids")
    public Result<List<T>> findByIds(@RequestBody List<? extends Serializable> idList) {
        List<T> result = service.findByIds(idList);
        return Result.success("success", result);
    }

    /**
     * 查询所有记录（慎用，数据量大时可能影响性能）
     * @return 所有记录列表
     */
    @GetMapping
    public Result<List<T>> findAll() {
        List<T> result = service.findAll();
        return Result.success("success", result);
    }

    /**
     * 分页查询所有记录
     * @param pageQuery 分页参数
     * @return 分页结果
     */
    @PostMapping("/page")
    public Result<IPage<T>> findPage(@RequestBody PageQuery pageQuery) {
        IPage<T> page = pageQuery.toPage();
        IPage<T> result = service.findPage(page);
        return Result.success("success", result);
    }

    /**
     * 根据查询条件查询记录列表
     * @param entity 查询条件对象
     * @return 查询结果列表
     */
    @PostMapping("/search")
    public Result<List<T>> search(@RequestBody T entity) {
        QueryWrapper<T> queryWrapper = buildQueryWrapper(entity);
        List<T> result = service.findList(queryWrapper);
        return Result.success("success", result);
    }

    /**
     * 根据查询条件分页查询记录
     * @param pageQuery 分页参数
     * @param entity 查询条件对象
     * @return 分页查询结果
     */
    @PostMapping("/search/page")
    public Result<IPage<T>> searchPage(@RequestBody PageQuery pageQuery, T entity) {
        IPage<T> page = pageQuery.toPage();
        QueryWrapper<T> queryWrapper = buildQueryWrapper(entity);
        IPage<T> result = service.findPage(page, queryWrapper);
        return Result.success("success", result);
    }

    /**
     * 查询当前实体的记录总数
     * @return 总数
     */
    @GetMapping("/count")
    public Result<Long> count() {
        long result = service.count();
        return Result.success("success", result);
    }

    /**
     * 根据查询条件统计记录总数
     * @param entity 查询条件对象
     * @return 记录数
     */
    @PostMapping("/count")
    public Result<Long> count(@RequestBody T entity) {
        QueryWrapper<T> queryWrapper = buildQueryWrapper(entity);
        long result = service.count(queryWrapper);
        return Result.success("success", result);
    }

    /**
     * 构建查询条件，子类可重写此方法以自定义查询逻辑
     * @param entity 查询条件对象
     * @return QueryWrapper 构建结果
     */
    protected QueryWrapper<T> buildQueryWrapper(T entity) {
        return new QueryWrapper<>(entity);
    }
}

